Java Assignment Rehberi – Stack, Heap, Pass-by-Value

Java’da assignment (atama) konusunu gerçekten anlamak istiyorsan, sadece “değer kopyalanır” demek yetmez. Çünkü işin içine stack & heap, primitive vs reference, casting, scope, shadowing ve özellikle pass-by-value girince çoğu kişinin kafası karışıyor.

Bu rehber, özellikle SCJP / OCA-OCP tarzı Java sınavlarında çok çıkan tuzakları netleştirir ve bol örnekle konuyu oturtur.

1) Stack ve Heap: Java’nın Hafıza Yapısı

Java programlarında bellek kabaca iki ana alanda düşünülür:

• Stack: Metot çağrıları, local değişkenler, parametreler
• Heap: Nesneler (new), instance variable’lar, array’ler

✅ Altın kural: Değişken stack’te, nesne heap’te yaşar.

class Dog {
  String name;   // instance variable - heap
  Collar c;      // instance variable - heap

  public static void main(String[] args) {
    Dog d = new Dog();  // d -> stack, Dog object -> heap
    d.go(d);
  }

  void go(Dog dog) {     // dog -> stack (reference copy)
    c = new Collar();    // Collar object -> heap
    dog.setName("Aiko");
  }

  void setName(String dogName) {
    name = dogName;
  }
}

class Collar { }

Burada kritik nokta şudur: d ve dog iki farklı stack değişkenidir ama heap’te aynı Dog nesnesini işaret ederler.

2) Primitive vs Reference Assignment

Primitive tipler (değer kopyalanır)

Primitive tiplerde atama, direkt değerin kopyalanması demektir. Bu yüzden değişkenler birbirinden bağımsız çalışır.

int a = 10;
int b = a;
b = 30;

System.out.println(a); // 10
System.out.println(b); // 30

✅ Sonuç: a değişmez, çünkü b tamamen ayrı bir değere sahiptir.

Reference tipler (referans kopyalanır)

Reference tiplerde kopyalanan şey nesnenin kendisi değil, nesnenin adresi / referansıdır.

import java.awt.Dimension;

Dimension a = new Dimension(5, 10);
Dimension b = a;

b.height = 30;

System.out.println(a.height); // 30

✅ Çünkü a ve b aynı heap nesnesini paylaşır.

3) String Neden Farklı?

String’ler reference tip olmasına rağmen, immutable (değiştirilemez) oldukları için “farklı” davranır.

String x = "Java";
String y = x;

x = x + " Bean";

System.out.println(y); // Java
System.out.println(x); // Java Bean

Burada String nesnesi “içerik olarak” değişmez. Yeni bir String üretilir ve x artık yeni nesneyi gösterir.

⚠️ Sınav tuzağı: String referansı paylaşılsa bile içerik değişmiyor gibi görünür, çünkü aslında her değişiklik yeni nesne üretir.

4) Pass-by-Value (En Kritik Konu)

✅ Java’da parametre aktarımı %100 pass-by-value’dur. Yani metoda gönderilen şey kopyadır.

Primitive parametre

static void modify(int n) {
  n++;
}

int a = 1;
modify(a);

System.out.println(a); // 1

Çünkü metoda giden a’nın kopyasıdır.

Object parametre

import java.awt.Dimension;

static void modify(Dimension d) {
  d.height++;
}

Dimension x = new Dimension(5, 10);
modify(x);

System.out.println(x.height); // 11

Burada metoda giden şey referansın kopyasıdır. Ama bu kopya da aynı nesneyi işaret ettiği için nesnenin içi değişebilir.

✅ Özet:

• Java pass-by-reference değildir
• Metot çağıranın referansını değiştiremez
• Ama nesnenin iç alanlarını değiştirebilir

5) Shadowing (Gölgeleme)

Shadowing, aynı isimli bir parametrenin veya local değişkenin dıştaki değişkeni gizlemesi durumudur.

class Foo {
  static int size = 7;

  static void changeIt(int size) {
    size += 200;
  }

  public static void main(String[] args) {
    changeIt(size);
    System.out.println(size); // 7
  }
}

Burada metoda gelen size parametresi, sınıftaki Foo.size değişkenini gölgeler.

✅ Eğer gerçekten static değişkeni değiştirmek isteseydik:

static void changeIt(int size) {
  Foo.size += 200;
}

6) Mini Cheat Sheet

• Local variable default değer almaz (kullanmadan önce initialize etmelisin)
• Instance variable default değer alır (0, false, null)
• byte + byte = int (aritmetik işlemler int’e yükseltir)
• String immutable olduğu için değişiklik yeni nesne üretir
• Java %100 pass-by-value
• Shadowing fark edilmezse gizli bug çıkarır

Sonuç

Java’da atama (assignment) konusunu anlamanın en hızlı yolu, “stack’te referans, heap’te nesne” mantığını net oturtmaktır. Primitive tiplerde değer kopyalanır, reference tiplerde referans kopyalanır.

Eğer SCJP / OCP tarzı sınavlara hazırlanıyorsan, özellikle pass-by-value ve shadowing sorularına ekstra dikkat etmelisin.